#include "FenScores.h"
#include "../Iterator.h"
#include "../Ressources.h"
#include "../PlateForme/PlateForme.h"

#include <sstream>
#include <algorithm>


FenScores::FenScores(SDL_Surface *ecran , ListeChainee* vect) : Fenetre("scores",ecran)
{
    table = new SDL_Table(6,ecran);
    table->setTitre("place",0);
    table->setTitre("nombre",1);
    table->setTitre("moyenne",2);
    table->setTitre("minimum",3);
    table->setTitre("maximum",4);
    table->setTitre("pseudo",5);
    table->estSelectionable(false);

    SDL_Rect positionCentre;
    positionCentre.x = ecran->w/2 - 33/2;
    positionCentre.y = ecran->h - 120;
    Position p;
    p.x = positionCentre.x + 6;
    p.y = positionCentre.y - 33;
    p1 = new Pion(ecran,"ressources/images/pion.bmp" ,  "ressources/images/pion2.bmp" , p );
	PlateForme *sC = new PlateForme(positionCentre,Ressources::get_image(POD1) , ecran);
    podium.push_back(sC);
    SDL_Rect positionGauche ;
    positionGauche.x = positionCentre.x - 31 ;
    positionGauche.y = positionCentre.y + sC->getTaille().h - 36;
    p.x = positionGauche.x - 5 ;
    p.y = positionGauche.y - 33;
    p2 = new Pion(ecran,"ressources/images/pion2.bmp" ,  "ressources/images/pion2.bmp" , p );
	PlateForme *sG = new PlateForme(positionGauche,Ressources::get_image(POD2) , ecran);
    podium.push_back(sG);
    SDL_Rect positionDroite;
    positionDroite.x = positionCentre.x + sC->getTaille().w ;
    positionDroite.y = positionCentre.y +  sC->getTaille().h - 30 ;
    p.x = positionDroite.x + 5;
    p.y = positionDroite.y - 33;
    p3 = new Pion(ecran,"ressources/images/pion.bmp" ,  "ressources/images/pion.bmp" , p );
	PlateForme *sD = new PlateForme(positionDroite,Ressources::get_image(POD3) , ecran);
    podium.push_back(sD);


    setScores(vect);
}

int FenScores::afficher()
{
    vector<Monstre*> tabMon ;
    vector<Accessoir*> tabAcces;

    /**** deffinition des boutons ***/
    FondBouton fBoutonIn;
    FondBouton fBoutonOut;
    fBoutonIn.image = IMG_Load("ressources/images/boutonMenu/boutonin.png");
    fBoutonIn.largeurDroite = 32;
    fBoutonIn.largeurGauche = 32;

    fBoutonOut.image = IMG_Load("ressources/images/boutonMenu/boutonout.png");
    fBoutonOut.largeurDroite = 32;
    fBoutonOut.largeurGauche = 32;

    SDL_Color noir = {0,0,0};
    Bouton *quitter = new Bouton("quitter","arial.ttf" , 20,&fBoutonOut , &fBoutonIn);
    Bouton *maximal =  new Bouton("maximum","arial.ttf" , 20,&fBoutonOut , &fBoutonIn);
    Bouton *moyenne =  new Bouton("moyenne","arial.ttf" , 20,&fBoutonOut , &fBoutonIn);
    Bouton *mini = new Bouton("minimum","arial.ttf" , 20,&fBoutonOut , &fBoutonIn);
    Bouton *nombrePartie = new Bouton("partie","arial.ttf" , 20,&fBoutonOut , &fBoutonIn);

    quitter->setColorIn(noir);
    maximal->setColorIn(noir);
    moyenne->setColorIn(noir);
    mini->setColorIn(noir);
    nombrePartie->setColorIn(noir);

    bool fin = false;
    SDL_Event event;

    while(!fin)
    {
        Fenetre::afficher();
        SDL_PollEvent(&event);

        switch(event.type)
        {
        case SDL_QUIT:
            exit(1);
            break;
        }


        /*** on affiche la tableau des scores***/
        SDL_Rect posit;
        posit.x = ecran->w/2 - table->getTaille().w/2;
        posit.y = 80;
        table->setHauteur(ecran->h - 350);
        table->afficher(posit,event);

        /*** on affiche le podium ***/
        std::vector<PlateForme*>::iterator finTabCube = podium.end();
        for(std::vector<PlateForme*>::iterator iter = podium.begin() ; iter != finTabCube ; iter++)
        {
            (*iter)->afficher();
        }
        /****** on affiche les pions ***/
      /*  p1->calculerPosition(podium,tabMon,tabAcces);
        p2->calculerPosition(podium,tabMon,tabAcces);
        p3->calculerPosition(podium,tabMon,tabAcces);
        */
        p1->afficher();
        p2->afficher();
        p3->afficher();

        /**** on affiche les boutons ****/
        int somme = quitter->w()+maximal->w()+moyenne->w()+mini->w()+nombrePartie->w() + 4*10;
        quitter->afficher(ecran , ecran->w/2 - somme/2 , ecran->h - quitter->h() - 10  , event);
        maximal->afficher(ecran , ecran->w/2 - somme/2 + quitter->w() + 10 , ecran->h - quitter->h() - 10  , event);
        moyenne->afficher(ecran , ecran->w/2 - somme/2 + quitter->w() + maximal->w() + 20 , ecran->h - quitter->h() - 10  , event);
        mini->afficher(ecran,ecran->w/2 - somme/2 + quitter->w() + maximal->w() + 20 + moyenne->w() + 10 , ecran->h - quitter->h() - 10,event);
        nombrePartie->afficher(ecran,ecran->w/2 - somme/2 + quitter->w() + maximal->w() + 20 + moyenne->w() + 10 + mini->w() + 10, ecran->h - quitter->h() - 10 ,event);
        fin = quitter->isClicked();

        if(maximal->isClicked())
            changerMode(MAX);
        else if( moyenne->isClicked())
            changerMode(MOYENNE);
        else if(mini->isClicked())
            changerMode(MIN);
        else if(nombrePartie->isClicked())
            changerMode(NBPARTI);
        /**** on blit l'ecran ***/
        SDL_Flip(ecran);
    }


    delete quitter;
    SDL_FreeSurface(fBoutonIn.image);
    SDL_FreeSurface(fBoutonOut.image);
}
/*
void FenScores::setScores(vector<Score_struct> vect)
{
    vecMoyen.clear();

    //on parcourt toute la liste pour voir si n'y a pas deja qqn pour ce score
    std::vector<Score_struct>::iterator finScore = vect.end();
    //on parcout tout le cube en regardant leurs amplitude (l'espace qu'ils occupent)
    for(std::vector<Score_struct>::iterator iter = vect.begin() ; iter != finScore ; iter++)
    {
        ajouterScore(*iter);
    }

   changerMode(MOYENNE);
}
*/
 void FenScores::setScores(ListeChainee* vect){
	vecMoyen.clear();

	Iterator iter = vect->iterator();
	while(iter.hasNext()){
	    ajouterScore( *((Score_struct_Moyenne*)(iter.next())));
	}

	std::cout << "on a  ajouter tout les score " << vect->size() << ","<< vecMoyen.size() << std::endl;

    changerMode(MOYENNE);
 }


 void FenScores::changerMode(int mode ){
    table->removeAll();

     switch(mode){
        case MAX :
             std::sort (vecMoyen.begin(), vecMoyen.end(), TriParMax());
        break;
        case MOYENNE :
             std::sort (vecMoyen.begin(), vecMoyen.end(), TriParMoyenne());
        break;
        case MIN :
            std::sort (vecMoyen.begin(), vecMoyen.end(), TriParMini());
        break;
        case NBPARTI :
             std::sort (vecMoyen.begin(), vecMoyen.end(), TriNbPartie());
    }

//    std::sort(vecMoyen.begin() , vecMoyen.end() , TriTable());
     //on va tout ajouter dans lal iste chainne
    std::vector<Score_struct_Moyenne>::iterator finScoreVac = this->vecMoyen.end();
    //on parcout tout le cube en regardant leurs amplitude (l'espace qu'ils occupent)
    int i = 0;
    for( std::vector<Score_struct_Moyenne>::iterator iter = this->vecMoyen.begin() ; iter != finScoreVac ; i++,iter++)
    {
        Score_struct_Moyenne act = *iter;
        switch(i)
        {
        case 0 :
            p1->setNom(act.nom);
            break;
        case 1:
            p2->setNom(act.nom);
            break;
        case 2:
            p3->setNom(act.nom);
            break;
        }

        vector<string> vec ;

        std::stringstream hors0;
        hors0 << i+1 << ".";
        vec.push_back(hors0.str());

        std::stringstream hors1;
        hors1 << act.nbPartie;
        vec.push_back(hors1.str());

        std::stringstream hors2;
        hors2 << act.valMoy;
        vec.push_back(hors2.str());

        std::stringstream hors4;
        hors4 << act.valMin;
        vec.push_back(hors4.str());

          std::stringstream hors3;
        hors3 << act.valMax;
        vec.push_back(hors3.str());


        vec.push_back(act.nom);

        table->add(vec);
    }
 }
void FenScores::ajouterScore(Score_struct_Moyenne sc)
{
    //on parcourt toute la liste pour voir si n'y a pas deja qqn pour ce score
    std::vector<Score_struct_Moyenne>::iterator finScore = vecMoyen.end();
    //on parcout tout le cube en regardant leurs amplitude (l'espace qu'ils occupent)
    for(std::vector<Score_struct_Moyenne>::iterator iter = vecMoyen.begin() ; iter != finScore ; iter++)
    {
        Score_struct_Moyenne moyenneAct = *iter;
        if(moyenneAct.nom == sc.nom) //si on a trouver le mm nom
        {
            (iter)->valMoy =  sc.valMoy /*((moyenneAct.valMoy * moyenneAct.nbPartie) + sc.val)/(moyenneAct.nbPartie+1)*/;
            (iter)->valMax = sc.valMax;
            (iter)->valMin = sc.valMin;
            (iter)->nbPartie = sc.nbPartie;
            (iter)->nom = sc.nom;
            return;
        }
    }

    //si non on doit crer un nouveau score
   /* Score_struct_Moyenne nouv;
    nouv.valMax = nouv.valMoy = nouv.valMin = sc.val;
    nouv.nbPartie = 1;
    nouv.nom = sc.nom;
    */
    vecMoyen.push_back(sc);
}
